home *** CD-ROM | disk | FTP | other *** search
/ PC-SIG Library 8 / PC-SIG Library CD-ROM (8th Edition) (1990-04).iso / 201_300 / disk0223 / preview.asm < prev    next >
Encoding:
Assembly Source File  |  1987-01-13  |  8.5 KB  |  228 lines

  1. TITLE PARSE.ASM - WORD COUNT PROCEDURE
  2. NAME PARSE
  3. PAGE 77,132
  4. ;
  5. ; RETURNS CHAR COUNT, WORD AND SENTENCE COUNT
  6. ; COUNT OF ASCII FILES COMPILED INTO READING LEVEL INDEX
  7. ;
  8. CSECT    SEGMENT PARA PUBLIC 'CODE'
  9.          ASSUME    CS:CSECT,DS:CSECT,SS:NOTHING,ES:NOTHING
  10.          ORG       100H
  11. ENTRY:   JMP       START
  12. ;
  13. ; SKIP SMALL DATA SEGMENT]
  14. ;
  15. CHAR_COUNT DW      0
  16. CHAR_CT_CARRY DW   0
  17. LINE_COUNT    DW   0
  18. LINE_CT_CARRY DW   0
  19. DISPLAY_FLAG  DB   0
  20. fsize          dw    0    ;total bytes...
  21. fsize_cy      dw    0    ;carry?
  22. started    db    0    ;<> 0 when data read...
  23. ;
  24. maxpage    equ    66    ;lines per page for defaults
  25. alpha_string  db   ' printable characters',13,10,'$'
  26. file_size     db    ' bytes in file',13,10,'$'
  27. word_string   db   ' words',13,10,'$'
  28. line_string   db   ' lines',13,10,'$'
  29. page_string   db   ' pages @ 66 Ln/Pg',13,10,'$'
  30. carry_64k     db   '65536+$'
  31. ;
  32. source   db        13,10,'CP file unreachable,RC=255',13,10,'$'
  33. eofmsg   db        'EOF reached.',13,10,'$'
  34. nodata    db    'Warning: File is empty',13,10,'$'
  35. ENDMSG   DB        13,10,'COMMAND COMPLETE',13,10,'$'
  36. errmsg   db        13,10,'CP File read failure',13,10
  37.          DB        'COMMAND PROCESSING ABEND,RC=2',13,10,'$'
  38. begmsg   db        'Execution begins ...',13,10,'$'
  39. ;
  40. ;
  41. ; BEFORE THE FILE CAN BE PARSED, THE COMMAND LINE HAS TO BE
  42. ; PARSED.  THEN THE FILE WILL BE OPENED AND READ TO MAIN STORAGE
  43. ;
  44. START:
  45.          MOV       DI,80H              ;POINT TO PARMS
  46.          MOV       BL,[DI]             ;THE NUMBER OF CHARS
  47.          XOR       BH,BH               ;ZERO TOP HALF
  48.          MOV       BYTE PTR DS:[BX+DI+1],0
  49. NEXT_BYTE:
  50.          INC       DI                  ;POINT TO NEXT BYTE
  51.          CMP       BYTE PTR DS:[DI],32 ;A SPACE DELIMITER?
  52.          JZ        NEXT_BYTE           ;YES - SKIP DELIMITERS
  53.          MOV       DX,DI
  54.          MOV       AX,3D00H            ;OPEN THE FILE...
  55.          INT       21H                 ;VIA CP
  56.          JC        EXIT                ;ERRORS DURING OPEN
  57.          PUSH      AX                  ;SAVE FILE HANDLE
  58.          MOV       DX,OFFSET BEGMSG
  59.          CALL      DISPLAY_TEXT        ;WRITE THE START MSG...
  60.          POP       AX                  ;RECOVER...
  61.          PUSH      AX                  ;IF OK, RECOVER THE FILEHANDLE
  62. READ:    POP       BX                  ;INTO THE RIGHT REGISTER
  63.          PUSH      BX
  64.          MOV       DX,OFFSET BUFFER    ;POINT TO DTA
  65.          MOV       CX,64000            ;~64K BYTES IN BUFFER ZONE
  66.          MOV       AH,3FH              ;READ FROM FILE
  67.          INT       21H                 ;WITH CP
  68.          JC        CLOSE_FILE          ;IF FAILURE, STOP WITH CP
  69.          CMP       AX,0                ;EOF REACHED?
  70.          JNZ       PARSE               ;IF NOT, PARSE NEXT BATCH
  71. GO_DISPLAY:
  72.          MOV       DX,OFFSET EOFMSG    ;END REACHED
  73.          CALL      DISPLAY_TEXT        ;WRITE THE MESSAGE
  74.          CMP       FSIZE,1             ;ONLY THE EOF MARK?
  75.          JA        DATA                ;NO - WRITE THE SUMMARY
  76.          MOV       DX,OFFSET NODATA
  77.          CALL      DISPLAY_TEXT
  78.          JMP       CLOSE_FILE
  79. DATA:
  80.          CALL      DISPLAY             ;WRITE THE SUMMARY WITH CP
  81. CLOSE_FILE:
  82.          JNC       OK                  ;JUST CONTINUE
  83.          MOV       DX,OFFSET ERRMSG    ;FILE READ ERROR
  84.          CALL      DISPLAY_TEXT        ;WRITE AND STOP
  85. OK:
  86.          POP       BX                  ;FIXUP STACK
  87.          MOV       AH,3EH              ;AND CLOSE FILE
  88.          INT       21H                 ;CALL CP
  89.          JC        NOT_OK
  90.          MOV       DX,OFFSET ENDMSG
  91.          CALL      DISPLAY_TEXT        ;END MESSAGE
  92.          CLC                           ;CLEAR CARRY AFTER MESSAGE...
  93. NOT_OK:  INT       20H                 ;CP KILLS PROCESS...
  94. EXIT:
  95.          JNC       OK2                 ;
  96.          MOV       DX,OFFSET SOURCE
  97.          CALL      DISPLAY_TEXT
  98. OK2:                                   ;MESSAGE IS WRITTEN...
  99.          INT       20H                 ;CP TERMINATION
  100. ;
  101. ; EACH BYTE OF THE FILE WILL BE EXAMINED AND THE APPROPRIATE COUNTER
  102. ; WILL BE INCREMENTED (WORD, SENTENCE TOO) LONG WORDS WILL BE COUNTED
  103. ; WHEN 8 CHARS OR MORE
  104. ;
  105. PARSE:   MOV       CX,AX               ;SET COUNTER TO BYTES READ
  106.          MOV       SI,OFFSET BUFFER
  107.          CLD
  108. GET_CHAR:
  109.          ADD       FSIZE,1             ;
  110.          ADC       FSIZE_CY,0
  111.          LODSB
  112.          AND       AL,7FH              ;STRIP WS HI - BIT IF THERE
  113.          CMP       AL,32               ;PRINTABLE?
  114.          JB        DELIMITER           ;IF YES, NOT PRINTABLE...
  115.          ADD       CHAR_COUNT,1        ;ADD 1 TO CHAR COUNT
  116.          ADC       CHAR_CT_CARRY,0     ;AND ONE EXTRY IN CASE OVERFLOW
  117.          JMP       NOCR                ;CAN'T BE...
  118. DELIMITER:
  119.          CMP       AL,0DH              ;A CR ?
  120.          JNE       NOCR
  121.          ADD       LINE_COUNT,1
  122.          ADC       LINE_CT_CARRY,0
  123. NOCR:
  124.          LOOP      GET_CHAR            ;AND CONTINUE...
  125.          JMP       READ                ;NEXT BLOCK WHEN LOOP EXPIRED
  126. ;
  127. ;
  128. ; SUBROUTINE AREA BEGINS
  129. ;
  130. DISPLAY: MOV       DL,10               ;LINEFEED FIRST
  131.          MOV       AH,02               ;JUST TO MAKE OUTPUT PRETTY
  132.          INT       21H                 ;CP WRITES OUTPUT
  133.          CMP       CHAR_CT_CARRY,0     ;DID CHAR COUNT OVERFLOW?
  134.          JZ        NO_CARRY            ;NO JUST CONTINUE
  135.          MOV       DX,OFFSET CARRY_64K
  136.          MOV       AH,9                ;AT LEAST THAT MANY + MORE...
  137.          INT       21H                 ;
  138. NO_CARRY:MOV       BX,CHAR_COUNT       ;SAME WITH LOW HALF
  139.          CALL      NUMBERS
  140.          MOV       DX,OFFSET ALPHA_STRING
  141.          CALL      DISPLAY_TEXT
  142.          CMP       FSIZE_CY,0
  143.          JZ        NOFCY               ;NO FILE CARRY
  144.          MOV       DX,OFFSET CARRY_64K
  145.          MOV       AH,09H
  146.          INT       21H                 ;WRITE THE MESSAGE
  147. NOFCY:   MOV       BX,FSIZE            ;THE COMPLETE SIZE
  148.          CALL      NUMBERS             ;WRITE THE TOTAL SIZE...
  149.          MOV       DX,OFFSET FILE_SIZE
  150.          CALL      DISPLAY_TEXT        ;WRITE IT WITH CHARACTERS
  151.          CMP       LINE_CT_CARRY,0
  152.          JZ        NOCRY               ;NO CR CARRY VALUE USED
  153.          MOV       DX,OFFSET CARRY_64K
  154.          MOV       AH,09
  155.          INT       21H
  156. NOCRY:
  157.          MOV       BX,LINE_COUNT
  158.          CALL      NUMBERS
  159.          MOV       DX,OFFSET LINE_STRING
  160.          CALL      DISPLAY_TEXT
  161.          CALL      PGCALC
  162.          CALL      NUMBERS             ;BX ALREADY SET
  163.          MOV       DX,OFFSET PAGE_STRING
  164.          CALL      DISPLAY_TEXT        ;WRITE IT.
  165.          RET                           ;FINSHED AT LAST...
  166. ;
  167. ;
  168. NUMBERS: MOV       CX,10000            ;GET 10KS.
  169.          CALL      DIVIDE              ;
  170.          MOV       CX,1000             ;1KS
  171.          CALL      DIVIDE
  172. TENTHS:  MOV       CX,100              ;100S
  173.          CALL      DIVIDE
  174.          MOV       CX,10
  175.          CALL      DIVIDE
  176.          MOV       CX,1
  177.          CALL      DIVIDE
  178.          MOV       DISPLAY_FLAG,0
  179.          RET                           ;BACK TO CALLER...
  180. ;
  181. ;
  182. DIVIDE:  MOV       AX,BX
  183.          XOR       DX,DX
  184.          DIV       CX
  185.          MOV       BX,DX
  186.          MOV       DL,AL
  187.          CMP       AL,0
  188.          JZ        FLAG
  189.          OR        DISPLAY_FLAG,AL
  190. FLAG:    CMP       DISPLAY_FLAG,0
  191.          JNZ       DISP_NUMBER
  192.          MOV       DL,-10H             ;PAD WITH BLANKS.
  193. DISP_NUMBER:
  194.          ADD       DL,30H              ;ASCII WEIGHT
  195.          MOV       AH,2H               ;DISPLAY VIA CP
  196.          INT       21H
  197.          RET                           ;CP RETURNS
  198. ;
  199. ;
  200. DISPLAY_TEXT:
  201.          MOV       AH,09H              ;WRITE A MSG WITH CP
  202.          INT       21H
  203.          RET                           ;BACK TO CALLER
  204. ;
  205. ;
  206. ;
  207. PGCALC:
  208.          MOV       AX,LINE_COUNT
  209.          XOR       DX,DX
  210.          MOV       BX,MAXPAGE
  211.          DIV       BX
  212.          CMP       AX,0
  213.          JNE       NOINCR              ;IF NEEDED
  214.          INC       AX
  215. NOINCR:  MOV       BX,AX               ;BX IS SET
  216.          CMP       DX,0                ;WAS IT EVEN DIVISION?
  217.          JE        NOFIX               ;YES - BLOW OUT
  218.          INC       BX                  ;OTHERWISE, HANDLE THE REMAINDER
  219.          CMP       AX,66               ;BUT NOT IF < 66 TO START ...
  220.          JA        NOFIX               ;OK AS IS...
  221.          DEC       BX                  ;RESTORE TO 1
  222. NOFIX:
  223.          RET                           ;ALL SET...
  224. ;
  225. BUFFER:                                ;MARK BUFFER ZONE...
  226. CSECT    ENDS
  227.          END       ENTRY               ;COMPLETED.
  228.